{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from scipy import ndarray\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors=['lightgray','blue','red','green','purple','navy','violet','darkorange','gray','gray','gray','lawngreen','darkmagenta','black','thistle','indianred']\n",
    "current_palette = sns.color_palette(colors)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "%config InlineBackend.figure_format = 'svg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_majority.csv'\n",
    "datapd_0=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_minority.csv'\n",
    "datapd_1=pd.read_csv(filename, index_col=0 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_val_1.csv'\n",
    "dataval_1=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_val_2.csv'\n",
    "dataval_2=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class dataframe shape: (16383, 23)\n",
      "Minority class dataframe shape: (625, 23)\n"
     ]
    }
   ],
   "source": [
    "print('Majority class dataframe shape:', datapd_0.shape)\n",
    "print('Minority class dataframe shape:', datapd_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_feat=datapd_0.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Imbalance Ratio: 26.2128\n"
     ]
    }
   ],
   "source": [
    "print('Imbalance Ratio:', datapd_0.shape[0]/datapd_1.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_0_trn=np.asarray(datapd_0)\n",
    "features_1_trn=np.asarray(datapd_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_val1=np.asarray(dataval_1)\n",
    "features_val2=np.asarray(dataval_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lr(X_train,y_train,X_test):\n",
    "    from sklearn import metrics\n",
    "    from sklearn.neighbors import KNeighborsClassifier\n",
    "    from sklearn.metrics import confusion_matrix\n",
    "    from sklearn.metrics import f1_score\n",
    "    from sklearn.metrics import average_precision_score\n",
    "    from sklearn.metrics import balanced_accuracy_score    \n",
    "    knn = KNeighborsClassifier(n_neighbors=10)\n",
    "    knn.fit(X_train, y_train)\n",
    "    y_pred= knn.predict(X_test)\n",
    "    return(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Neb_grps(data,near_neb):\n",
    "    nbrs = NearestNeighbors(n_neighbors=near_neb, algorithm='ball_tree').fit(data)\n",
    "    distances, indices = nbrs.kneighbors(data)\n",
    "    neb_class=[]\n",
    "    for i in (indices):\n",
    "        neb_class.append(i)\n",
    "    return(np.asarray(neb_class)) \n",
    "\n",
    "def LoRAS(data,num_samples,shadow,sigma,num_RACOS,num_afcomb):\n",
    "    np.random.seed(42)\n",
    "    data_shadow=([])\n",
    "    for i in range (num_samples):\n",
    "        c=0\n",
    "        while c<shadow:\n",
    "            data_shadow.append(data[i]+np.random.normal(0,sigma))\n",
    "            c=c+1\n",
    "    data_shadow==np.asarray(data_shadow)\n",
    "    data_shadow_lc=([])\n",
    "    for i in range(num_RACOS):\n",
    "        idx = np.random.randint(shadow*num_samples, size=num_afcomb)\n",
    "        w=np.random.randint(100, size=len(idx))\n",
    "        aff_w=np.asarray(w/sum(w))\n",
    "        data_tsl=np.array(data_shadow)[idx,:]\n",
    "        data_tsl_=np.dot(aff_w, data_tsl)\n",
    "        data_shadow_lc.append(data_tsl_)\n",
    "    return(np.asarray(data_shadow_lc))   \n",
    "\n",
    "def LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb):\n",
    "    RACOS_set=[]\n",
    "    for i in range (len(nb_list)):\n",
    "        RACOS_i= LoRAS(features_1_trn[nb_list[i]],num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "        RACOS_set.append(RACOS_i)\n",
    "    LoRAS_set=np.asarray(RACOS_set)\n",
    "    LoRAS_1=np.reshape(LoRAS_set,(len(features_1_trn)*num_RACOS,n_feat))\n",
    "    return(np.concatenate((LoRAS_1,features_1_trn)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Without preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "features=np.concatenate((features_1_trn,features_0_trn))\n",
    "labels=np.concatenate((np.zeros(len(features_1_trn))+1, np.zeros(len(features_0_trn))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1.75 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "y_pred_norm1=knn(features,labels,features_val1)\n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(y_pred_norm1==1)]\n",
    "\n",
    "with open('predict_val1_20_norm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.74 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "y_pred_norm2=knn(features,labels,features_val2)\n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(y_pred_norm2==1)]\n",
    "\n",
    "with open('predict_val2_20_norm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py:92: NumbaPerformanceWarning: \u001b[1m\u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\utils.py\", line 409:\u001b[0m\n",
      "\u001b[1m@numba.njit(parallel=True)\n",
      "\u001b[1mdef build_candidates(current_graph, n_vertices, n_neighbors, max_candidates, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\u001b[0m\n",
      "  current_graph, n_vertices, n_neighbors, max_candidates, rng_state\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\spectral.py:229: UserWarning: Embedding a total of 35 separate connected components using meta-embedding (experimental)\n",
      "  n_components\n"
     ]
    }
   ],
   "source": [
    "import umap.umap_ as umap\n",
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(features)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 2},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LoRAS overampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 35 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "num_samples=30\n",
    "shadow=100\n",
    "sigma=.005\n",
    "num_RACOS=(len(features_0_trn)-len(features_1_trn))//len(features_1_trn)\n",
    "num_afcomb=50\n",
    "nb_list=Neb_grps(features_1_trn, num_samples)\n",
    "    \n",
    "LoRAS_1=LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "LoRAS_train=np.concatenate((LoRAS_1,features_0_trn))\n",
    "LoRAS_labels=np.concatenate((np.zeros(len(LoRAS_1))+1, np.zeros(len(features_0_trn))))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(LoRAS_train,LoRAS_labels,features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_LoRAS.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 33.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "num_samples=30\n",
    "shadow=100\n",
    "sigma=.005\n",
    "num_RACOS=(len(features_0_trn)-len(features_1_trn))//len(features_1_trn)\n",
    "num_afcomb=50\n",
    "nb_list=Neb_grps(features_1_trn, num_samples)\n",
    "    \n",
    "LoRAS_1=LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "LoRAS_train=np.concatenate((LoRAS_1,features_0_trn))\n",
    "LoRAS_labels=np.concatenate((np.zeros(len(LoRAS_1))+1, np.zeros(len(features_0_trn))))\n",
    "    \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.14 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(LoRAS_train,LoRAS_labels,features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_LORAS.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "feats=np.concatenate((LoRAS_train[np.where(LoRAS_labels==1)][np.random.choice(len(LoRAS_train[np.where(LoRAS_labels==1)]), 2000, replace=False)], LoRAS_train[np.where(LoRAS_labels==0)]))\n",
    "labs=np.concatenate((np.zeros(2000)+1,np.zeros(len(LoRAS_train[np.where(LoRAS_labels==0)]))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\spectral.py:229: UserWarning: Embedding a total of 40 separate connected components using meta-embedding (experimental)\n",
      "  n_components\n"
     ]
    }
   ],
   "source": [
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(feats)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 2},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.neighbors.base module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.bagging module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.base module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.forest module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "Using TensorFlow backend.\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.utils.testing module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.utils. Anything that cannot be imported from sklearn.utils is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.metrics.classification module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.metrics. Anything that cannot be imported from sklearn.metrics is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import SMOTE \n",
    "sm = SMOTE(random_state=62, k_neighbors=30,  kind='regular',ratio=1)\n",
    "SMOTE_feat, SMOTE_labels = sm.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.56 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat, SMOTE_labels, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_SMOTE.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 4.18 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat, SMOTE_labels, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_SMOTE.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "feats=np.concatenate((SMOTE_feat[np.where(SMOTE_labels==1)][np.random.choice(len(SMOTE_feat[np.where(SMOTE_labels==1)]), 2000, replace=False)], SMOTE_feat[np.where(SMOTE_labels==0)]))\n",
    "labs=np.concatenate((np.zeros(2000)+1,np.zeros(len(SMOTE_feat[np.where(SMOTE_labels==0)]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\spectral.py:229: UserWarning: Embedding a total of 39 separate connected components using meta-embedding (experimental)\n",
      "  n_components\n"
     ]
    }
   ],
   "source": [
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(feats)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 2},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE bl1 oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import SMOTE \n",
    "smbl1 = SMOTE(random_state=62, k_neighbors=30,  kind='borderline1',ratio=1)\n",
    "SMOTE_feat_bl1, SMOTE_labels_bl1 = smbl1.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.38 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_bl1, SMOTE_labels_bl1, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_SMOTE_bl1.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.83 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_bl1, SMOTE_labels_bl1, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_SMOTE_bl1.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE bl2 oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "smbl2 = SMOTE(random_state=62, k_neighbors=30,  kind='borderline2',ratio=1)\n",
    "SMOTE_feat_bl2, SMOTE_labels_bl2 = smbl1.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.57 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_bl2, SMOTE_labels_bl2, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_SMOTE_bl2.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 4.46 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_bl2, SMOTE_labels_bl2, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_SMOTE_bl2.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE SVM oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "smsvm = SMOTE(random_state=62, k_neighbors=30,  kind='svm',ratio=1)\n",
    "SMOTE_feat_svm, SMOTE_labels_svm = smsvm.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.79 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_svm, SMOTE_labels_svm, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_SMOTE_svm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 4.39 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_svm, SMOTE_labels_svm, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_SMOTE_svm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ADASYN oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import ADASYN\n",
    "ad = ADASYN(random_state=62,n_neighbors=30,  ratio=1)\n",
    "ADASYN_feat, ADASYN_labels = ad.fit_resample(features, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.15 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(ADASYN_feat, ADASYN_labels, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_20_ADASYN.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.24 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(ADASYN_feat, ADASYN_labels, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_20_ADASYN.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
